home *** CD-ROM | disk | FTP | other *** search
/ World of Sound / World of Sound.iso / utils / miditools / obersuite-1.03 / sourcecode / fromfile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-23  |  4.0 KB  |  194 lines
  1. /**************************************************************************
  2. * fromfile.c:    Functions for reading patch data from a disk file.
  3. *        A part of OberSuite for the Commodore Amiga.
  4. *
  5. * Author:    Daniel Barrett, barrett@cs.umass.edu.
  6. * Version:    1.0.
  7. * Copyright:    None!  This program is in the Public Domain.
  8. *        Please share it with others.
  9. ***************************************************************************/
  10.  
  11. #include "decl.h"
  12.  
  13. /*
  14.  * Read patch data from the named file into the PATCHINFO structure.
  15.  * Return TRUE if successful, or FALSE if not.
  16.  * Possible things that can go wrong:
  17.  *
  18.  *    OpenReadFile() might be unable to open the file.
  19.  *    The user could press ^C.
  20.  *    read() might not read the correct number of bytes from the file.
  21.  *     (Correct number == (number of patches) * (size of 1 patch))
  22.  */
  23.  
  24. BOOL GetPatchFromFile(PATCHINFO *pi, char *filename)
  25. {
  26.     int fd = 0;
  27.     long bytesRead, shouldRead;
  28.  
  29.     if (fd = OpenReadFile(filename))
  30.     {
  31.         if (CtrlcCheck())
  32.         {
  33.             close(fd);
  34.             ErrorMsg(ERROR_CTRLC);
  35.             return(FALSE);
  36.         }
  37.  
  38.         shouldRead = pi->numPatches * pi->rightSize;
  39.         bytesRead = read(fd, pi->data, shouldRead);
  40.  
  41.         if (shouldRead != bytesRead)
  42.             ErrorMsg(ERROR_READFILE);
  43.  
  44.         close(fd);
  45.         return(bytesRead == shouldRead);
  46.     }
  47.     else
  48.         return(FALSE);
  49. }
  50.  
  51.  
  52. /*
  53.  * Return TRUE if the size of the given file is a valid size for a patch
  54.  * file.  From the actual size, determine the "rightSize" and "numPatches"
  55.  * values for the PATCHINFO structure.
  56.  */
  57.  
  58. BOOL LookAtFileSize(PATCHINFO *pi, char *filename)
  59. {
  60.     long size = 0L;
  61.     BOOL success = TRUE;
  62.  
  63.     if ((size = FileSize(filename)) < 0L)
  64.         {
  65.         success = FALSE;
  66.         ErrorMsg(ERROR_FINDFILE);
  67.     }
  68.     else if ((size == SINGLE_SIZE)
  69.     ||     (size == XPANDER_MULTI_SIZE)
  70.     ||     (size == MATRIX12_MULTI_SIZE))
  71.     {
  72.         pi->rightSize = size;
  73.         pi->numPatches = 1;
  74.     }
  75.     else if ((size == ALL_SINGLE_SIZE)
  76.     ||     (size == ALL_XPANDER_MULTI_SIZE)
  77.     ||     (size == ALL_MATRIX12_MULTI_SIZE))
  78.     {
  79.         pi->rightSize = size / NUM_PATCHES;
  80.         pi->numPatches = NUM_PATCHES;
  81.     }
  82.     else
  83.     {
  84.         success = FALSE;
  85.         ErrorMsg(ERROR_FILESIZE);
  86.     }
  87.  
  88.     if (!success && ERR_OUTPUT_ALLOWED)
  89.     {
  90.         fprintf(stderr, "(File \"%s\"", filename);
  91.         if (size > 0)
  92.             fprintf(stderr, ", size=%ld", size);
  93.         fprintf(stderr, ")\n");
  94.     }
  95.     return(success);
  96. }
  97.  
  98.  
  99. /*
  100.  * Given a PATCHINFO structure filled with patch data, verify that the
  101.  * data is consistent.
  102.  */
  103.  
  104. BOOL VerifyAllPatches(PATCHINFO *pi)
  105. {
  106.         int i;
  107.     long offset = 0L;
  108.  
  109.     for (i=0; (pi) && (i < pi->numPatches); i++)
  110.     {
  111.         if (!VerifyPatch(pi, offset))
  112.         {
  113.             if (ERR_OUTPUT_ALLOWED)
  114.             {
  115.                fprintf(stderr,
  116.                  "Verify failed after checking %ld patch(es).\n",
  117.                  i);
  118.             }
  119.             return(FALSE);
  120.         }
  121.         offset += pi->rightSize;
  122.     }
  123.     return(TRUE);
  124. }    
  125.  
  126.  
  127. /*
  128.  * Look at the patch data in a PATCHINFO structure, and determine:
  129.  *
  130.  *    The patch mode.
  131.  *    The (string) name of the patch mode.
  132.  *
  133.  * Fill in these fields in the PATCHINFO struct.
  134.  */
  135.  
  136. BOOL FigureThingsOutFromHeader(PATCHINFO *pi)
  137. {
  138.     /* We do this to get through Verify().  actualSize is meaningless
  139.      * until we actually see the results of DoTheIO().  We calculated
  140.      * rightSize when we stat()-ed the file. */
  141.  
  142.     pi->actualSize = pi->rightSize;
  143.  
  144.     pi->mode = pi->data[BYTE_PATCHTYPE];
  145.     switch (pi->mode)
  146.     {
  147.         case SINGLE_DATA:
  148.             strcpy(pi->modeName, NAME_SINGLE);
  149.             return(TRUE);
  150.         case MULTI_DATA:
  151.             strcpy(pi->modeName, NAME_MULTI);
  152.             return(TRUE);
  153.         default:
  154.             ErrorMsg(ERROR_UNKNOWNVOICEDATA);
  155.             return(FALSE);
  156.     }
  157. }
  158.  
  159. /*
  160.  * Given a filename, open that file for reading.  Return the file descriptor.
  161.  */
  162.  
  163. int OpenReadFile(char *filename)
  164. {
  165.     int fd=NULL;
  166.  
  167.     if ((fd = open(filename, O_RDONLY)) == -1)
  168.         {
  169.         if (ERR_OUTPUT_ALLOWED)
  170.             fprintf(stderr, "%s: ", filename);
  171.         ErrorMsg(ERROR_FINDFILE);
  172.         return(NULL);
  173.     }
  174.     else
  175.         return(fd);
  176. }
  177.  
  178. /*
  179.  * Given a filename, return the size (in bytes) of that file.
  180.  * If the file cannot be found, return the error value returned by stat().
  181.  * which is -1.
  182.  */
  183.  
  184. long FileSize(char *filename)
  185. {
  186.     struct stat statbuf;
  187.     int result;
  188.  
  189.     if ((result = stat(filename, &statbuf)) < 0)
  190.         return((long)result);
  191.     else
  192.         return(statbuf.st_size);
  193. }
  194.